package com.xuecheng.media.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.j256.simplemagic.ContentInfo;
import com.j256.simplemagic.ContentInfoUtil;
import com.xuecheng.base.enums.CourseEnum;
import com.xuecheng.base.exception.XueChengPlusException;
import com.xuecheng.base.model.PageParams;
import com.xuecheng.base.model.PageResult;
import com.xuecheng.base.model.RestResponse;
import com.xuecheng.media.mapper.MediaFilesMapper;
import com.xuecheng.media.model.dto.QueryMediaParamsDto;
import com.xuecheng.media.model.dto.UploadFileParamsDto;
import com.xuecheng.media.model.dto.UploadFileResultDto;
import com.xuecheng.media.model.po.MediaFiles;
import com.xuecheng.media.service.MediaFileService;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.omg.CORBA.SystemException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.*;
import java.text.SimpleDateFormat;

import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @description TODO
 * @author Mr.M
 * @date 2022/9/10 8:58
 * @version 1.0
 */
 @Service
public class MediaFileServiceImpl extends ServiceImpl<MediaFilesMapper, MediaFiles> implements MediaFileService{

  @Autowired
 MediaFilesMapper mediaFilesMapper;

 @Autowired
 MediaFileService mediaFilesService;

 @Autowired
 MinioClient minioClient;

 @Autowired
 //没有事务的方法，里面去调用有事务的方法，会导致事务失效，例如下面的uploadFile方法去调用addMediaFilesToDb。解决: 使用代理对象去调用
 MediaFileService mediaFilesServiceProxy;//自己注入自己，注入进来的必然是代理对象，代理对象调用的方法，此方法的事务必然不会失效

 //图片文件桶
 @Value("${minio.bucket.files}")
 private String bucket_mediafiles;

 @Override
 public PageResult<MediaFiles> queryMediaFiels(Long companyId, PageParams pageParams, QueryMediaParamsDto queryMediaParamsDto) {
  //构建查询条件对象
  LambdaQueryWrapper<MediaFiles> queryWrapper = new LambdaQueryWrapper<>();
  queryWrapper.like(MediaFiles::getFilename,queryMediaParamsDto.getFilename());
  //分页对象
  Page<MediaFiles> page = new Page<>(pageParams.getPageNo(), pageParams.getPageSize());
  // 查询数据内容获得结果
  Page<MediaFiles> pageResult = mediaFilesMapper.selectPage(page, queryWrapper);
  // 获取数据列表
  List<MediaFiles> list = pageResult.getRecords();
  // 获取数据总数
  long total = pageResult.getTotal();
  // 构建结果集
  PageResult<MediaFiles> mediaListResult = new PageResult<>(list, total, pageParams.getPageNo(), pageParams.getPageSize());
  return mediaListResult;
 }

 //------------------------------------整合minio-上传图片--------------------------------------

 @Override
 public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath) {
  File file = new File(localFilePath);
  if (!file.exists()) {
   XueChengPlusException.cast("文件不存在");
  }
  //文件名称
  String filename = uploadFileParamsDto.getFilename();
  //文件扩展名
  String extension = filename.substring(filename.lastIndexOf("."));
  //文件mimeType
  String mimeType = getMimeType(extension);
  //文件的md5值，也就是不包含后缀的文件名
  String fileMd5 = getFileMd5(file);
  //文件的默认目录
  String defaultFolderPath = getDefaultFolderPath();
  //存储到minio的文件名，目录+文件名+后缀
  String  objectName = defaultFolderPath + fileMd5 + extension;
  //将文件上传到minio
  boolean result = this.addMediaFilesToMinIO(localFilePath, mimeType, bucket_mediafiles, objectName);
  if(!result) {
   XueChengPlusException.cast("上传文件失败");
  }
  //文件大小
  uploadFileParamsDto.setFileSize(file.length());
  //将文件信息保存到数据库
  MediaFiles mediaFiles = mediaFilesServiceProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_mediafiles, objectName);
  //准备返回数据
  UploadFileResultDto uploadFileResultDto = new UploadFileResultDto();
  BeanUtils.copyProperties(mediaFiles, uploadFileResultDto);
  return uploadFileResultDto;

 }

 //--------------------------------整合minio-上传文件的通用方法----------------------------------

 //获取文件默认存储目录路径 年/月/日
 private String getDefaultFolderPath() {
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  String folder = sdf.format(new Date()).replace("-", "/")+"/";//例如 2024/04/21/
  return folder;
 }
 //获取文件的md5
 private String getFileMd5(File file) {
  try (FileInputStream fileInputStream = new FileInputStream(file)) {
   String fileMd5 = DigestUtils.md5Hex(fileInputStream);
   return fileMd5;
  } catch (Exception e) {
   e.printStackTrace();
   return null;
  }
 }
 private String getMimeType(String extension){
  if(extension==null)
   extension = "";
  //根据扩展名取出mimeType
  ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
  //通用mimeType，字节流
  String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
  if(extensionMatch!=null){
   mimeType = extensionMatch.getMimeType();
  }
  return mimeType;
 }
 /**
  * @description 将文件写入minIO
  * @param localFilePath  文件地址
  * @param bucket  桶
  * @param objectName 对象名称
  */
 public boolean addMediaFilesToMinIO(String localFilePath,String mimeType,String bucket, String objectName) {
  try {
   UploadObjectArgs testbucket = UploadObjectArgs.builder()
           .bucket(bucket)
           .object(objectName)
           .filename(localFilePath)
           .contentType(mimeType)
           .build();
   minioClient.uploadObject(testbucket);
   System.out.println("上传成功");
   return true;
  } catch (Exception e) {
   System.out.println("上传文件失败");
   e.printStackTrace();
  }
  return false;
 }
 /**
  * @description 将文件信息添加到数据库
  * @param companyId  机构id
  * @param fileMd5  文件md5值，也就是文件名(不包含后缀)
  * @param uploadFileParamsDto  上传文件的信息
  * @param bucket  桶
  * @param objectName 对象名称
  */
 @Transactional
 public MediaFiles addMediaFilesToDb(Long companyId, String fileMd5, UploadFileParamsDto uploadFileParamsDto, String bucket, String objectName){
  //判断这个文件是否在数据库已存在。fileMd5就是文件名(不包含后缀)
  MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
  if (mediaFiles == null) {//不存在的话，就把这个文件的信息插入数据库。minio那边如果是重复文件，新上传的会覆盖后上传的
   mediaFiles = new MediaFiles();
   //bean拷贝
   BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
   mediaFiles.setId(fileMd5);
   mediaFiles.setFileId(fileMd5);
   mediaFiles.setCompanyId(companyId);
   mediaFiles.setUrl("/" + bucket + "/" + objectName);
   mediaFiles.setBucket(bucket);
   mediaFiles.setFilePath(objectName);
   mediaFiles.setCreateDate(LocalDateTime.now());
   mediaFiles.setAuditStatus(CourseEnum.MINIO_AUDIT_YES.getCode());//默认审核通过
   mediaFiles.setStatus(CourseEnum.MINIO_FILE_YES.getCode());//文件默认是展示状态
   //保存文件信息到数据库
   int insert = mediaFilesMapper.insert(mediaFiles);
   if (insert <= 0) {
    XueChengPlusException.cast("保存文件信息失败");
   }
   System.out.println("上传成功");

  }
  return mediaFiles;
 }

 //存储视频
 @Value("${minio.bucket.videofiles}")
 private String bucket_video;

 /**
  * @description 检查文件是否存在
  * @param fileMd5 文件的 md5
  * @return com.xuecheng.base.model.RestResponse<java.lang.Boolean>
 false 不存在，true 存在
  * @author Mr.M
  * @date 2022/9/13 15:38
  */
 @Override
 public RestResponse<Boolean> checkFile(String fileMd5) {
  //先查询数据库
  MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
  if(mediaFiles!=null){
   //桶
   String bucket = mediaFiles.getBucket();
   //objectname
   String filePath = mediaFiles.getFilePath();
   //如果数据库存在再查询 minio
   GetObjectArgs getObjectArgs = GetObjectArgs.builder()
           .bucket(bucket)
           .object(filePath)
           .build();
   //查询远程服务获取到一个流对象
   try {
    FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
    if(inputStream!=null){
     //文件已存在
     return RestResponse.success(true);
    }
   } catch (Exception e) {
    e.printStackTrace();
   }

  }

  //文件不存在
  return RestResponse.success(false);
 }

 /**
  * @description 检查分块是否存在
  * @param fileMd5 文件的 md5
  * @param chunkIndex 分块序号
  * @return com.xuecheng.base.model.RestResponse<java.lang.Boolean>
 false 不存在，true 存在
  * @author Mr.M
  * @date 2022/9/13 15:39
  */
 @Override
 public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {

  //根据md5得到分块文件所在目录的路径
  String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);

  //如果数据库存在再查询 minio
  GetObjectArgs getObjectArgs = GetObjectArgs.builder()
          .bucket(bucket_video)
          .object(chunkFileFolderPath+chunkIndex)
          .build();
  //查询远程服务获取到一个流对象
  try {
   FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
   if(inputStream!=null){
    //文件已存在
    return RestResponse.success(true);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }

  //文件不存在
  return RestResponse.success(false);
 }


 /**
  * @description 上传分块
  * @param fileMd5 文件 md5
  * @param chunk 分块序号
  * @param localChunkFilePath 分块文件本地路径
  * @return com.xuecheng.base.model.RestResponse
  * @author Mr.M
  * @date 2022/9/13 15:50
  */
 @Override
 public RestResponse uploadChunk(String fileMd5, int chunk, String localChunkFilePath) {
  //分块文件的路径
  String chunkFilePath = getChunkFileFolderPath(fileMd5) + chunk;
  //获取mimeType
  String mimeType = getMimeType(null);
  //将分块文件上传到minio
  boolean b = addMediaFilesToMinIO(localChunkFilePath, mimeType, bucket_video, chunkFilePath);
  if(!b){
   return RestResponse.validfail(false,"上传分块文件失败");
  }
  //上传成功
  return RestResponse.success(true);
 }

 @Override
 public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {
  //分块文件所在目录
  String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
  //找到所有的分块文件
  List<ComposeSource> sources = Stream.iterate(0, i -> ++i).limit(chunkTotal).map(i -> ComposeSource.builder().bucket(bucket_video).object(chunkFileFolderPath + i).build()).collect(Collectors.toList());
  //源文件名称
  String filename = uploadFileParamsDto.getFilename();
  //扩展名
  String extension = filename.substring(filename.lastIndexOf("."));
  //合并后文件的objectname
  String objectName = getFilePathByMd5(fileMd5, extension);
  //指定合并后的objectName等信息
  ComposeObjectArgs composeObjectArgs = ComposeObjectArgs.builder()
          .bucket(bucket_video)
          .object(objectName)//合并后的文件的objectname
          .sources(sources)//指定源文件
          .build();
  //===========合并文件============
  //报错size 1048576 must be greater than 5242880，minio默认的分块文件大小为5M
  try {
   minioClient.composeObject(composeObjectArgs);
  } catch (Exception e) {
   e.printStackTrace();
   return RestResponse.validfail(false,"合并文件异常");
  }

  //===========校验合并后的和源文件是否一致，视频上传才成功===========
  //先下载合并后的文件
  //File file = downloadFileFromMinIO(bucket_video, objectName); //这里非常消耗网络，前端请求执行到这行时会直接自动断掉，如果是线上的话就不要校验了
  //try(FileInputStream fileInputStream = new FileInputStream(file)){
  //    //计算合并后文件的md5
  //    String mergeFile_md5 = DigestUtils.md5Hex(fileInputStream);
  //    //比较原始md5和合并后文件的md5
  //    if(!fileMd5.equals(mergeFile_md5)){
  //        return RestResponse.validfail(false,"文件校验失败");
  //    }
  //    //文件大小
  //    uploadFileParamsDto.setFileSize(file.length());
  //}catch (Exception e) {
  //    return RestResponse.validfail(false,"文件校验失败");
  //}

  //==============将文件信息入库============
  MediaFiles mediaFiles = mediaFilesServiceProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_video, objectName);
  if(mediaFiles == null){
   return RestResponse.validfail(false,"文件入库失败");
  }
  //==========清理分块文件=========
  clearChunkFiles(chunkFileFolderPath,chunkTotal);

  return RestResponse.success(true);
 }

 /**
  * 清除分块文件
  * @param chunkFileFolderPath 分块文件路径
  * @param chunkTotal 分块文件总数
  */
 private void clearChunkFiles(String chunkFileFolderPath,int chunkTotal){
  Iterable<DeleteObject> objects =  Stream.iterate(0, i -> ++i).limit(chunkTotal).map(i -> new DeleteObject(chunkFileFolderPath+ i)).collect(Collectors.toList());;
  RemoveObjectsArgs removeObjectsArgs = RemoveObjectsArgs.builder().bucket(bucket_video).objects(objects).build();
  Iterable<Result<DeleteError>> results = minioClient.removeObjects(removeObjectsArgs);
  //要想真正删除
  results.forEach(f->{
   try {
    DeleteError deleteError = f.get();
   } catch (Exception e) {
    e.printStackTrace();
   }
  });

 }
 /**
  * 从minio下载文件
  * @param bucket 桶
  * @param objectName 对象名称
  * @return 下载后的文件
  */
 public File downloadFileFromMinIO(String bucket,String objectName){
  //临时文件
  File minioFile = null;
  FileOutputStream outputStream = null;
  try{
   InputStream stream = minioClient.getObject(GetObjectArgs.builder()
           .bucket(bucket)
           .object(objectName)
           .build());
   //创建临时文件
   minioFile=File.createTempFile("minio", ".merge");
   outputStream = new FileOutputStream(minioFile);
   IOUtils.copy(stream,outputStream);
   return minioFile;
  } catch (Exception e) {
   e.printStackTrace();
  }finally {
   if(outputStream!=null){
    try {
     outputStream.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }
  return null;
 }

 /**
  * 得到合并后的文件的地址
  * @param fileMd5 文件id即md5值
  * @param fileExt 文件扩展名
  * @return
  */
 private String getFilePathByMd5(String fileMd5,String fileExt){
  return   fileMd5.substring(0,1) + "/" + fileMd5.substring(1,2) + "/" + fileMd5 + "/" +fileMd5 +fileExt;
 }

 //得到分块文件的目录
 private String getChunkFileFolderPath(String fileMd5) {
  return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
 }
}
